home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’95 / Venus / SimpleWindow.cc < prev    next >
Text File  |  1995-06-23  |  9KB  |  332 lines
  1. /*
  2.  ***********************************************************************
  3.  *
  4.  *
  5.  *                                Simple Window Class
  6.  *        
  7.  *
  8.  ***********************************************************************
  9.  */
  10.  
  11. #include "std.h"
  12. #include "image.h"
  13. #include "window.h"
  14. #include <PictUtil.h>
  15.  
  16. /*
  17.  *----------------------------------------------------------------------
  18.  *                            Service functions
  19.  */
  20.  
  21.                                         // Getting a bounding rectangle of an image
  22. ScreenRect::ScreenRect(const IMAGE& image)
  23. {
  24.     top = 0;
  25.     bottom = top + image.q_nrows();
  26.     left = 0;
  27.     right = left + image.q_ncols();
  28. }
  29.  
  30.                                     // Create a rectangle of given height/width
  31.                                     // positioned at the origin
  32. ScreenRect::ScreenRect(const rowcol& heightwidth)
  33. {
  34.     left = top = 0;
  35.     bottom = heightwidth.row();
  36.     right  = heightwidth.col();
  37. }
  38.  
  39.                                     // Create a rectangle of given height/width
  40.                                     // positioned at a given point
  41. ScreenRect::ScreenRect(const rowcol& origin, const rowcol& heightwidth)
  42. {
  43.     top  = origin.row();
  44.     left = origin.col();
  45.     bottom = top+heightwidth.row();
  46.     right  = left+heightwidth.col();
  47. }
  48.  
  49.  
  50.                                     // Shifting a rectangle by the same amount
  51.                                     // in X and Y
  52. ScreenRect& ScreenRect::operator += (const int offset)
  53. { 
  54.     top += offset; bottom += offset; left += offset; right += offset;
  55.     return *this;
  56. }
  57.  
  58.  
  59.                                     // Print what rectangle is this
  60. void ScreenRect::print(const char * title) const
  61. {
  62.     message("Rectangle %s (%d,%d) - (%d,%d)",title,top,left,bottom,right);
  63. }
  64.  
  65.  
  66.  
  67.                                     // Used to "implicitly" convert from C to Pascal
  68.                                     // string
  69. Pstr::Pstr(const char * c_str)
  70. {
  71.     strncpy((char *)pas_string,c_str,sizeof(*this)-2);
  72.     CtoPstr((char *)pas_string);
  73. }
  74.  
  75. /*
  76.  *----------------------------------------------------------------------
  77.  *        A generic simple window that can be dragged around the screen
  78.  *                and closed by clicking a "go-away" button
  79.  * No other events are handled, redefine the event handler if necessary.
  80.  */
  81.  
  82.  
  83.                                     // Create a color window of the specified size and title
  84.                                     // Note, the upper left corner of 'rect' must
  85.                                     // NOT be (0,0)!
  86. ScreenWindow::ScreenWindow(ScreenRect rect, const char * title)
  87. {
  88.     const int window_offset = 100;        // Cannot be 0 or small!
  89.     this_window = NewCWindow(nil,rect += window_offset,(Pstr)title,
  90.                             TRUE,noGrowDocProc,
  91.                             (WindowPtr)(-1),TRUE,(long)this);
  92.     assert( this_window != 0 );
  93.     SetPort(this_window);
  94.     SelectWindow(this_window);
  95. }
  96.  
  97.                                     // Create a color window from a resource template
  98. ScreenWindow::ScreenWindow(const short resource_id)
  99. {
  100.     this_window = GetNewCWindow(resource_id,nil,(WindowPtr)(-1));
  101.     SetWRefCon(this_window,(long)this);
  102.     assert( this_window != 0 );
  103.     SetPort(this_window);
  104.     SelectWindow(this_window);
  105. }
  106.  
  107.  
  108.  
  109.                                     // Close the window and clean up the rubble
  110. ScreenWindow::~ScreenWindow(void)
  111. {
  112.     assert( this_window != 0 );
  113.     DisposeWindow(this_window);
  114.     this_window = 0;
  115. }
  116.  
  117.  
  118.                                     // Event handling loop. Returns only when the
  119.                                     // window is to be destroyed
  120. void ScreenWindow::handle(void)
  121. {
  122.     const long event_timeout = 1;
  123.     EventRecord    theEvent;
  124.     unsigned long int prev_tick_count = 0;
  125.      
  126.     for(;;)
  127.     {
  128.         if( !WaitNextEvent(everyEvent, &theEvent,event_timeout,nil) )
  129.           if( handle_null_event(theEvent.when) )
  130.             continue;
  131.           else
  132.             return;
  133.           switch (theEvent.what)
  134.         {
  135.           case mouseDown:
  136.             if( !handle_mouse_down(theEvent) )
  137.               return;                        // Window is to be closed (go-away buttin clicked)
  138.             break;
  139.             
  140.           case updateEvt:
  141.             if( this_window == (WindowPtr)theEvent.message )
  142.               update();
  143.             break;
  144.  
  145.           case keyDown:
  146.           case autoKey:
  147.             if( !handle_key_down(theEvent) )
  148.               return;                        // a "quit" key must've been pressed
  149.             break;
  150.                         
  151.           case activateEvt:
  152.             if( this_window == (WindowPtr)theEvent.message )
  153.               activate(theEvent.modifiers & 0x01);
  154.             break;
  155.         }  
  156.     }
  157.     
  158. }
  159.  
  160.                                 // Handle "mouse-down" events
  161.                                 // Returns FALSE if the user clicked within the
  162.                                 // go-away region of our window. Otherwise,
  163.                                 // returns TRUE
  164.                                 // Handles dragging if necessary and system clicks
  165. Boolean ScreenWindow::handle_mouse_down(const EventRecord& the_event)
  166. {
  167.     WindowPtr    wp;
  168.     short        windowPart = FindWindow (the_event.where, &wp);
  169.     
  170.     switch (windowPart)
  171.     {
  172.       case inSysWindow: 
  173.         SystemClick(&the_event, wp);
  174.         break;
  175.         
  176.       case inMenuBar:
  177.         break;
  178.  
  179.       case inContent:
  180.           break;
  181.           
  182.       case inDrag:
  183.           if (wp == this_window )
  184.             drag(the_event.where);
  185.           break;
  186.                       
  187.       case inGoAway:
  188.           return FALSE;
  189.     }
  190.     return TRUE;
  191. }
  192.  
  193.                                         // Handles key_down & auto_key events. Return FALSE
  194.                                         // if the window is to be closed down
  195. Boolean ScreenWindow::handle_key_down(const EventRecord& the_event)
  196. {
  197.     return FALSE;                        // Each key kills the application, sorry
  198. }
  199.  
  200.  
  201.                                         // Handles null events, when nothing happens for some
  202.                                         // time. Return FALSE when it's time to die
  203. Boolean ScreenWindow::handle_null_event(const long event_time)
  204. {
  205.     return TRUE;                            // Keep going
  206. }
  207.  
  208.                             // Private window parts
  209.                                     // Handle an update event - redraw the window
  210.                                     // A virtual function draw() is called to do
  211.                                     // the actual redrawing
  212. void ScreenWindow::update(void)
  213. {
  214.     GrafPtr    savePort;
  215.     
  216.     GetPort(&savePort);
  217.     SetPort(this_window);
  218.     BeginUpdate(this_window);
  219.     draw();
  220.     EndUpdate(this_window);
  221.     SetPort(savePort);
  222. }
  223.  
  224.                                     // Make the entire window being redrawn
  225. void ScreenWindow::refresh(void)
  226. {
  227. //    EraseRect(&this_window->portRect);
  228.     InvalRect(&this_window->portRect);            
  229. }
  230.  
  231.                                         // Handle an activate or deactivate event
  232. void ScreenWindow::activate (const Boolean go_active)
  233. {
  234.     if (go_active)
  235.       SetPort(this_window);
  236. }
  237.  
  238.  
  239. /*
  240.  *----------------------------------------------------------------------
  241.  *            A simple window with an offscreen window buffer
  242.  */
  243.  
  244.                                 // Allocate the buffer for the offscreen
  245.                                 // drawing and load CLUT (if clut_id != 0)
  246. OffScreenWindow::OffScreenWindow
  247.     (ScreenRect rect, const char * title, const short clut_id)
  248.     : ScreenWindow(rect,title), graf_world(nil)
  249. {
  250.     CTabHandle clut_handle = nil;
  251.     if( clut_id != 0 )
  252.     {                                // try to get a user CLUT with that resource id
  253.        clut_handle = GetCTable(clut_id);
  254.        assert( clut_handle != 0 );
  255.        SetWinColor(our_window(),(WinCTab**)clut_handle);
  256.     }
  257.     do_well( NewGWorld(&graf_world,8,rect,clut_handle,nil,0) );
  258.     assert( graf_world != (void *)0 );
  259.  
  260. //    if( clut_handle != nil )
  261. //      DisposCTable(clut_handle);        // CLUT has been copied, and can be disposed of now
  262.                                         // But careful! CLUT is associated with the window
  263.                                         // by SetWinColor(), so we don't dispose of it
  264.  
  265.                                         // Get hold of the offscreen pixmap
  266.     pixmap = GetGWorldPixMap(graf_world);        // and make sure it looks like
  267.     assert( pixmap != nil && *pixmap != nil );    // we can use it
  268.  
  269.     assert( (**pixmap).cmpCount == 1 );            // We have a color table index
  270.     assert( !PixMap32Bit(pixmap) );
  271.  
  272.     _height = abs((**pixmap).bounds.top - (**pixmap).bounds.bottom);
  273.     _width  = abs((**pixmap).bounds.right - (**pixmap).bounds.left);
  274.     _bytes_per_row = (**pixmap).rowBytes & 0x7fff;
  275.  
  276.     assert( _height > 0 && _height < 10000 );         // Just to play safe
  277.     assert( _width > 0 && _width <= _bytes_per_row );    
  278.  
  279.     activate_palette();                    // Activate palette for the window
  280. }
  281.  
  282.                                 // Dispose of the offscreen buffer
  283. OffScreenWindow::~OffScreenWindow(void)
  284. {
  285.     assert( graf_world != nil );
  286.     DisposeGWorld(graf_world);
  287.     graf_world = nil;
  288.     PaletteHandle window_palette = GetPalette(our_window());
  289.     if( window_palette != nil )                // dispose of our palette if was allocated
  290.     {
  291.         SetPalette(our_window(),nil,FALSE);
  292.         DisposePalette(window_palette);
  293.     }
  294.     pixmap = nil;
  295.     _height = _width = _bytes_per_row = 0;
  296. }
  297.  
  298.                                     // Make sure that the colors of our off-screen
  299.                                     // buffer would be displayed properly (or close enough)
  300.                                     // on screen
  301. void OffScreenWindow::activate_palette(void)
  302. {
  303.     CTabHandle window_ctab = (**pixmap).pmTable;
  304.     assert( window_ctab != nil && *window_ctab != nil );
  305.  
  306.     PaletteHandle palette = NewPalette((**window_ctab).ctSize,window_ctab,pmTolerant+pmExplicit,0);
  307.     assert( palette != nil );
  308.     SetPalette(our_window(),palette,TRUE);
  309.     do_well( QDError() );
  310.     ActivatePalette(our_window());    
  311.     do_well( QDError() );
  312. }
  313.  
  314.  
  315.                                 // Get a bounding rectangle for the window
  316. ScreenRect OffScreenWindow::q_bounds(void) const
  317. {
  318.     return (**pixmap).bounds;
  319. }
  320.  
  321.  
  322.                                     // Actual drawing - moving the picture from the
  323.                                     // offscreen grafworld to the onscreen one
  324. void OffScreenWindow::draw(void)
  325. {
  326.     assert( LockPixels(pixmap) );
  327.     Rect& pixmap_rect = (**pixmap).bounds;
  328.     CopyBits((const BitMap *)*pixmap, &qd.thePort->portBits, &pixmap_rect, 
  329.              &our_window()->portRect, /*ditherCopy*/ srcCopy, nil);
  330.     UnlockPixels(pixmap);
  331. }
  332.